The emitter used to walk the schema namespace itself, bucket types by kind,
dedup scalars, and run a second classification pass to split models into
input/output variants. That loop also leaked implementation details (an
`originalToMutated` back-map and a `TypeUsageResolver` that outlived
mutation) into the emitter's public shape.

Introduce `GraphQLMutationEngine.mutateSchema(schema, typeUsage)` that
returns a fully-classified `MutatedSchema`:

- Pre-bucketed models: `interfaces`, `outputModels`, `inputModels`
- Pre-classified operations: `queries`, `mutations`, `subscriptions`
- Derived metadata: `wrapperModels`, `scalarVariants`, `scalarSpecifications`

Classification happens inline during the walk. `typeUsage` is consumed
entirely inside the engine; the emitter hands it over and never touches
it again. `originalToMutated` no longer exists outside the engine.

Implementation lives in `src/mutation-engine/schema-mutator.ts` as a free
function called from the `GraphQLMutationEngine` class to avoid a circular
import between engine.ts and schema-mutator.ts.

The emitter's `emitSchema` reduces to: resolve type usage, call
`engine.mutateSchema`, report void-return diagnostics, check for empty
schema, build variant lookups, hand off to the (stubbed) renderer.

After the TypeGraph refactor in PR #77, ScalarVariant was removed from the
context module. Move it to schema-mutator.ts where it belongs since it's
part of the MutatedSchema interface.

Add the first set of Alloy JSX components for GraphQL type emission:
- EnumType: renders GraphQL enum definitions with member descriptions and deprecation
- ScalarType: renders custom scalar definitions with @specifiedBy support
- UnionType: renders union type definitions with model and scalar variant members
- GraphQLSchema: root context wrapper providing TspContext and GraphQLSchemaContext

Add component-level tests using renderSchema + printSchema to exercise the
real Alloy rendering pipeline. Each component is tested in isolation with a
lightweight test helper (renderComponentToSDL) that provides minimal context.

14 new tests covering: basic rendering, doc comments, deprecation, name
sanitization, @specifiedBy, union member registration, and scalar wrappers.

- Extract isScalarLikeType() to type-utils.ts shared utility, replacing
  duplicated inline check in union-type.tsx
- Replace unsafe `as Union` casts in union-type tests with assertUnionResult()
  helper that provides a clear error if the mutation returns a Model

Replace fragile .toContain() assertions with inline snapshots to match
TSP ecosystem best practices. This makes test output more readable and
maintainable by showing the complete expected SDL in one place.

The function was extracted from union-type.tsx in commit 6d47132e4
but the type-utils.ts hunk was dropped during the rebase due to
conflicts with 'Remove dead code from type-utils.ts' in the base.

- ScalarType: take specificationUrl as prop instead of from context
- component-test-utils: use minimal TypeGraph context
- scalar-type.test: pass specificationUrl as prop

- Mutate operations in schema-mutator so type references point to
  correctly mutated types (input params → mutated input models,
  return types → mutated output models)
- Fix nullable union replacement to mutate inner type with context
  (Address | null → AddressInput in input context)
- Add Input suffix to models in input context with double-suffix
  prevention (BookInput stays BookInput, not BookInputInput)
- Add comprehensive tests for input suffix, nullable union
  replacement, and operation type references

Models used as both input and output must be mutated separately:
- Output context produces 'Foo'
- Input context produces 'FooInput'

Previously, all models were mutated with Output context only, causing
duplicate type names when rendering both variants.

- Add withInputSuffix helper to prevent "PetInput" → "PetInputInput"
- Fix oneOf input unions to mutate variant types with input context
  (model variants now correctly get their Input suffix, e.g. Cat → CatInput)
- Refactor model.ts to use shared withInputSuffix helper

Add field-bearing type components that use the Field infrastructure
(already present from the parent branch):
- ObjectType: renders object types with fields, @compose interfaces,
  and @operationFields support
- InterfaceType: renders interface type definitions with fields
- InputType: renders input types with automatic Input suffix when a
  model appears in both input and output positions

17 new component tests covering: basic field rendering, doc comments,
optional/nullable fields, array/list types, deprecated fields,
interface implementation via @compose, and Input suffix logic.

…ed imports

- Add explanatory comment on getComposition/iface.name in object-type.tsx
  clarifying that pre-mutation names match post-mutation names (mutation
  engine doesn't rename models)
- Remove unused `type Model` import from all G2 test files

- Add @operationFields test to ObjectType (verifies operation field rendering)
- Add nested model reference test to ObjectType (verifies type references)
- Add empty model tests to ObjectType, InputType, InterfaceType
  (documents that GraphQL requires at least one field per type)

The mutation engine now handles all input/output type naming, so components
can use type.name directly without looking up whether a model has both
input and output variants.

- Remove implementation detail comments about mutation engine
- Remove redundant tests that were testing non-responsibility of the component
  (InputType doesn't add suffixes - that's not its job)

Replace fragile .toContain() assertions with inline snapshots to match
TSP ecosystem best practices. This makes test output more readable and
maintainable by showing the complete expected SDL in one place.

Brings the component-based GraphQL emitter online by wiring the data
pipeline from the foundation skeleton into Alloy JSX rendering.

New components:
- components/operations/query-type.tsx, mutation-type.tsx, subscription-type.tsx:
  render the three GraphQL root operation types
- components/operations/index.ts: barrel export
- components/type-collections.tsx: orchestrator that dispatches each
  classified-type bucket (scalars, enums, unions, interfaces, objects, inputs)
  into the appropriate leaf-type component

Emitter wiring:
- Rename src/emitter.ts → src/emitter.tsx
- Phase 5 now renders via Alloy's renderSchema, converts to SDL with
  graphql-js printSchema, and writes the output via emitFile
- Adds output-file option handling with interpolatePath

Testing:
- test/e2e.test.ts: single happy-path smoke test proving the full
  TypeSpec → mutation → classification → rendering → SDL pipeline works
- Update the existing test/emitter.test.ts data-pipeline test to now
  assert that SDL output is produced (Phase 5 is wired up)

Broader integration coverage (nullability, input/output splitting,
unions, enums, arrays, circular refs, deprecation, doc comments) lands
in a follow-up PR focused on tests.

Adds component tests for QueryType, MutationType, and SubscriptionType
using inline snapshots. Tests cover rendering with scalar return types,
model return types (with stub type registration), parameters, and empty
operation lists.

Updates renderComponentToSDL utility to support skipPlaceholderQuery
option for testing QueryType, while maintaining backwards compatibility
with existing tests that pass context overrides directly.

Also cleans up e2e and emitter tests to use consistent vitest expect()
assertions with toMatchInlineSnapshot() instead of mixed strictEqual
and .includes() checks.

- type-collections: components take data via props instead of context
- emitter: pass MutatedSchema data directly to collection components
- Use minimal TypeGraph context (just globalNamespace)

This aligns with the TypeGraph design where context is minimal and
components receive their data through props.